
    获取电脑信息
        var os = require('os');

    用来操作路径
        var path = require('path');
        获取后缀名字
            path.extname('');

    引入http模块
    // 代码块: node-http-server 
        var http = require('http');
    // 例
        // 引入http模块
        var http = require('http'); 
        /*
            request  获取url传过来的信息
            response   给浏览器的响应信息
        */
        http.createServer(function (request, response) {
            // 设置响应头
            response.writeHead(200, {'Content-Type': 'text/html; charset="utf-8"'});
                // text/plain 普通文本   text/html; charset="utf-8" 解决中文乱码  image/jpeg 图片，不需要charset字符串编码
            
            // 写入数据
            response.write('hello');   
            // 结束响应 否则客户端会一直等待  end支持 二进制  字符串
            response.end('Hello World 1111');
        }).listen(8081);// 端口

        console.log('Server running at http://127.0.0.1:8081/');
        // 修改内容需要ctrl+c后从新运行才能显示

    // 不同的路径不同的请求
        var url = require.url;
        if(url==='/'){
            response.end('index page');
        }else if (url === '/login'){

        }else {
            response.end('404 not found');
        }
        
    URL模块
        url.parse(); 
        // 解析 URL  
        // 第二个参数为true query返回为对象

        url.format(urlobject);  
        // parse 的逆向操作

        url.sesolve(form, to);
        // 添加或者替换地址

    nodejs自启动工具supervisor
        // 不停的watch你应用下的所有文件，发现有文件被修改就从新载入程序文件实现部署
        安装supervisor
            // npm install -g supervisor

    FS模块
    // 想要进行文件操作，必须引进fs这个核心模块 fs核心模块中，提供了所有文件操作相关的API
        
        //使用requeire 方法加载fs核心模块
        var fs = requeire('fs');
    
        读取文件 
        // 第一个参数是文件路径， 第二个是回调函数
            fs.readFile('./data/hello.js', function(error,data){
                /* 读取成功
                        data 数据
                        error null
                读取失败               error 用于判断读取是否成功
                        data  undefined
                        error  错误对象 */
                if(error) {
                    console.log('文件读取失败');// null 进不来 错误对象报错
                }
                else{
                    console.log(data.toString()); // 默认为2进制，转换成可显示字符
                }        
            });
        
        写文件 
        // 第一个参数是文件路径， 第二个是写入内容 第三个是回调函数
            fs.writeFile('./hello.js','nihao',function(){
                /*  成功  文件写入成功  error 是null
                    失败   文件写入失败   error是错误对象  */ 
                if(error) {
                    console.log('写入失败');
                }
                else{
                    console.log('写入成功');
                }
            });
        追加
        // 不存在的话创建并且写入
            fs.appendFile('message.txt', 'data to append',(error) => {} );
        重命名
        // 重命名，移动文件
            fs.rename('oldFile.txt', 'newFile.txt', (err) => {})
        删除文件
            fs.unlink('path/file.txt', (err) => {});
    
        检测是文件还是目录
            fs.stat('',);
        创建目录
            fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {});
        读取目录
            fs.readdir('.html', (error, data) => {});
        删除目录
            fs.rmdir('', (error) => {});
        
        从文件流中读取数据
            var ReadStream = fs.createReadStream('path')
            ReadStream.on() // 监听读取状况
        从文件流中写入文件
            var WriteStream = fs.creatWriteStream('path')
            WriteStream.write (data, 'utf-8') // 写入数据
            WriteStream.end() // 标记文件末尾
            WriteStream.on('finish', ()=>{
                console.log('写入完成'); // 有end() 才能监听写入完成
            })
        管道读写
            创建一个读取流一个写入流
            var ReadStream = fs.createReadStream('path');
            var WriteStream = fs.creatWriteStream('path');
            ReadStream.pipe(writeStream);

        
    自定义模块
     // node.js 没有全局作用域 只有模块作用域 外部访问不到内部，内部也访问不到外部
    
        require()
            // 加载文件模块并执行里面的代码 模块作用域不会相互影响
            // 拿到被加载文件模块导出的接口对象
            // 所有核心模块使用前都需要require 加载
    
        exports    
            // 每个文件模块都提供了一个对象 exports{} 默认为空对象
                // 把所有需要被外部访问的成员放到exports里面
                exports.xxx = xxx ;
                var ss = require('./另一文件');
                const { ReadStream, WriteStream } = require('fs');
                console.log(require.xxx)
                        
            module.exports
             // 全部暴露

        简略的引入自定义名字
            // npm init --yes  生成package.json
    
    包与npm
       包目录
        // package .json  包描述文件
        // bin 存放二进制文件
        // lib 存放javascript 代码目录
        // doc 存放文档目录

    // 通过npm 下载第三方包
       npm命令
        // npm install modulename 下载包 @版本号，指定版本安装
        // npm uninstall modulename 卸载包
        // npm i 查看并下载 依赖 package.json 的dependencies里对应的所有包信息
        // npm info 查看包的信息
    
    Async,Await
    // 结合promise 使用
    // Async让方法变成异步
    // await等待异步方法执行完成 必须得用在async方法里面
        async function test(){// 变为异步任务
            return new promise((resolve, reject) => {
                setTimeout(function(){
                    var name = '张三';
                    resolve(name);
                }, 1000);
            }) 
        }
        async function main() {
            var data = await test(); // 获取异步里面的数据
            console.log(data);
        }

路由
    针对不同请求的url处理不同的
    if (pathname=='/news'){

    }else if(pathname == '/dadsa')

EJS模块引擎
    // 把数据库的文件读取的数据绑定到html上
    const ejs = require('ejs');
   
    安装
        // npm install ejs
    ejs.render()
    // 引入  
    ejs.renderFile(filename, data, options, function(err, str){})
    // 渲染后端数据 
    /* filename 要加载的html  以.ejs结尾的文本
        <% %>  可以写入js语句 */ 
    // data 哪些数据要渲染到HTML上
    // options 参数

getpost
    Get 
    // 从指定的资源请求数据  一般用于获取数据
        var urlinfo = url.parse(request.url, ture);
        urlinfo.query; // req.query

    post
    // 从指定的资源提交要被处理的数据  一般用于提交数据
        var psotData = 's'; 
        // 数据块接收中
        reqonse.on('data', function(postDataChunk){
            postData += postDataChunk;
        });
        // 数据接收完毕，执行回调函数
        reqonse.on('end', function(){
            try {
                postData = JSON.parse(postData);
            }catch(e) {}
            reqonse.query = postData;
            console.log(querystring.parse(postData))
        })

注册方法
    let G= {};
    // 注册方法
    app.get = function(str, cd){
        G['str'] = cd;
    }
    /* G['/login'] = function(req, res) {
        res.send('hello'); 
        }*/
    // 执行方法
    app.get("/login", function (req, res){
        res.send("hello");
    })





EXpress
    // 在项目文件里安装 npm install express --save
    引入
        var express = require('express');
        var app  = express();

    配置路由
        app.get('/', function(req, res){
            res.send('hello');
        })// 显示数据  get
    动态路由
        app.get('/article/: id',function(req, res){
            var id = req.params['id'];
            res.send('动态路由' + id);
        })

      请求
        app.post('/', function(req, res){
            // post 请求 用于增加数据
        })
        app.put() // 用于修改数据
        app.delete() // 主要用于删除数据

    监听端口
        app.listen(3000, '127.0.0.1');



  EXPRESS使用EJS模块引擎
    安装
        // npm install ejs --save
    配置
        app.set("view engine", "ejs");
    使用
        res.render("index", {

        })
        // 渲染模板引擎 默认加载文本引擎的文件夹是view
        // index 为.ejs文件html
    指定模板位置
    // 默认模板位置在views
        app.set('views', __dirname +'/views'); 
            // __dirname 表示获取路径 /views 为新保存目录
    
    ejs后缀修改为HTML
        // 1 在app.js头上定义ejs
            var ejs = require('ejs');
            const { Session } = require('inspector');
        // 2 注册 html 模板引擎
            app.engine('html', ejs__express);
        // 3 将模板引擎换成html
            app.set('view engine', 'html');
        // 4 修改模板文件后缀为.html

    
    绑定数据
    // html内书写绑定
        // <%=h%>   
    绑定html
        // <%-h%>  
    条件判断
        // <%js语句%>
        /*  <% if(){} %>   
            <% else(){}  %>   */
    引入
        html内引入其他HTML
        // <% -include('foot.ejs') %>

    静态资源托管
    // 托管路由自动配置该文件夹下的目录
        app.use(experss.static('静态目录'));
    
    中间件
    // 匹配路由之前或者匹配路由完成以后做的一系列操作 
    // 中间件如果想往下匹配的话 next()

        应用级中间件
            // 用于权限判断 写在匹配路由前
            app.use(function(req,res,next){

                next()
            })
        路由级中间件
            // 用next()让路由继续向下匹配
            app.get('/', (req, res, next)=>{

            })
        错误处理中间件
            // 处理错误
            app.use(function(req,res,next){
                req.status(404).send('404')
            })
        内置中间件
            // 配置静态目录
            app.use(experss.static('静态目录'));

        第三方中间件
            body-parser中间件
            // 获取post提交的数据
            // 1 安装 npm install body-parser -- save
            // 2 引入 var bodyParser = require('body-parser')
            // 3 配置中间件获取post传来的数据
                /* app.use(bodyParser.urlencoded({ extended: false}))
                   app.use(bodyParser.json())   */
            // 4 接收post数据  req.body
        
    Cookie
    // 存储于访问者的计算机中的变量，可以用同一个浏览器访问同一个域名时候时候数据共享
        
        // 1 安装 npm install cookie-parser --save
        // 2 引入 
            var cookie = require('cookie-parser')
        // 3 配置 
            app.use(cookieParser())  
        // 4 设置
            /*  res.cookie("name", 'zhangshan', {maxAge: 1000*60*60}) 
                name 为共享数据名  
                {}内   maxAge 为过期时间 以毫秒为单位
                       signed  加密
                       path   哪些路由可以访问cookies 
                       domain  多个域命共享cookies*/
        // 5 获取
            req.cookies.name

        cookie的加密
            配置中间件的时候需要传入加密参数
                app.use(cookieParser('itying'))
                res.cookie("name", 'zhangshan', {maxAge: 1000*60*60, signed: true})
            用特殊方式获取
                req.signedCookies.name
                // 获取加密cookie

    Session
    // 另一种记录客户状态的机制 cookie保存在客户端浏览器中，session保存在服务器上
        // 1 安装 npm install express-session --save
        // 2 引入
            var sassion = require('express-session')
        // 3 配置
            app.use(session({
                secret: 'keyboard cat', // 服务端生成 session的签名
                resave: true,  // 强制保存
                saveUninitialized: true, // 强制将未初始化的session存储
                rolling: true, // 每次请求是重置cookie过期时间 默认未false
                cookie: {
                    maxAge: 1000*60,
                    secure: false  // true 表示只有http协议才能访问cookie
                }
            }))
        // 4 使用
            设置值
                req.session.name = 'zhangsan'
            获取值
                req.session.name
        // 销毁
            所有销毁
            // 设置session过期时间为0  会把所有的session都销毁
                req.session.cookie.maxAge = 0;
            指定销毁
                req.session.name='';
                req.session.destory('', function(){})
        
        express路由模块化
            var express = require('express')
            var router = express.Router()
            // 通过router配置路由
            router.get('/add', function(req, res){
                
            })
            router.get('/ccc', function(req, res){

            })
            module.exports = router; // 暴露

            挂载这个文件模块
            var user =require('./routes') // 根模块引入
            app.use('/add', add);
            app.use('/ccc', aa )
          官方搭建脚手架
        
    multer上传文件模块
        // 1 安装 npm install --save multer
        // 表单内配置   
            /* <form action='/profile' method = "post" 
                enctype='multipart/form-data'>
               <input type = 'file'  name = 'avatar'> */
        // express内获取表单传过来的文件
            var multer = require('multer');
            app.post('/profile', upload.single('avatar'), function(req, res, next){

            })


    